#!/usr/bin/env python3
"""
QuoteHub Stocks - 股票行情系统主入口
支持多种功能模块，通过命令行参数激活对应功能
"""

import sys
import argparse
from pathlib import Path

# 添加项目根目录到Python路径
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))

from modules.a_stock_monitor import create_monitor
from modules.a_stock_ranking import create_ranking_monitor
from modules.ai_stock_selector import create_ai_selector
from modules.ai_stock_selector_enhanced import create_enhanced_selector
from modules.ai_stock_selector_v2 import create_ai_selector_v2, SelectionStrategy, RiskLevel
from modules.kline_analyzer import create_kline_analyzer


def setup_argument_parser():
    """设置命令行参数解析器"""
    parser = argparse.ArgumentParser(
        description='QuoteHub Stocks - 股票行情系统',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
功能模块:
  a          A股实时行情监控
  rank       A股涨幅排名
  ai         DeepSeek AI智能选股器
  kline      K线技术分析和大资金识别
  trend      股票涨跌趋势排行
  
使用示例:
  🔥 A股实时行情监控 (支持多数据源智能切换)
  python main.py a --once             # 获取一次行情数据（推荐）
  python main.py a --interval 3       # 持续监控，3秒刷新间隔
  python main.py a --source sina --once      # 使用新浪数据源（推荐）
  python main.py a --source tencent --once   # 使用腾讯数据源（推荐）
  python main.py a --source yfinance --once  # 使用Yahoo Finance（备用，自动切换）
  python main.py a --test             # 测试数据源连接
  
  📈 A股涨跌幅排名 (支持多数据源)
  python main.py rank --top 50        # 获取涨幅排名TOP50
  python main.py rank --losers --top 20 # 获取跌幅排名TOP20
  python main.py rank --source sina   # 使用新浪数据源（推荐）
  python main.py rank --source tencent # 使用腾讯数据源（推荐）
  python main.py rank --source yfinance # 使用Yahoo Finance（备用）
  python main.py rank --limit         # 获取涨停股票榜
  
  🤖 DeepSeek AI智能选股器
  python main.py ai                   # 启动DeepSeek AI智能选股分析
  python main.py ai --count 15        # 选择15只推荐股票
  python main.py ai --source sina     # 使用新浪数据源
  python main.py ai --test            # 测试AI选股器连接
  python main.py ai --themes-only     # 仅显示题材分析
  python main.py ai --monthly-patterns # 显示月度炒作规律
  python main.py ai --no-ai           # 禁用AI分析，使用传统算法
  python main.py ai --api-key YOUR_KEY # 指定DeepSeek API密钥
  
  🚀 增强版AI选股器 (全市场扫描+新闻分析)
  python main.py enhanced             # 启动增强版AI选股器
  python main.py enhanced --count 10  # 选择10只推荐股票
  python main.py enhanced --source sina # 使用新浪数据源
  python main.py enhanced --theme 人工智能 # 特定题材深度分析
  python main.py enhanced --no-news   # 禁用新闻分析
  python main.py enhanced --min-price 5.0 # 最低股价筛选
  python main.py enhanced --max-price 300.0 # 最高股价筛选
  python main.py enhanced --min-volume 1000000 # 最小成交量筛选
  python main.py enhanced --exclude-st # 排除ST股票
  python main.py enhanced --api-key YOUR_KEY # 指定DeepSeek API密钥
  python main.py enhanced --test      # 测试增强版AI选股器连接
  
  🎯 AI选股器v2.0专业版 (多因子量化+DeepSeek R1)
  python main.py ai-v2                # 启动AI选股器v2.0专业版
  python main.py ai-v2 --count 8      # 选择8只推荐股票
  python main.py ai-v2 --strategy growth # 使用成长策略
  python main.py ai-v2 --risk aggressive # 积极风险偏好
  python main.py ai-v2 --sector 科技成长  # 指定板块分析
  python main.py ai-v2 --min-score 70  # 最低评分要求
  
  📊 K线技术分析和大资金识别
  python main.py kline 601611         # K线技术分析单只股票
  python main.py kline 601611 中国核建 # 指定股票名称
  python main.py kline 601611 --enhanced # 🆕 增强分析模式（推荐）
  python main.py kline --batch        # 批量分析股票列表
  python main.py kline --batch --enhanced # 🆕 增强批量分析
  python main.py kline --stocks "601611,002162,601668" --enhanced # 自定义列表增强分析
  python main.py kline --account-value 200000 --risk-tolerance 0.03 --enhanced # 个性化配置
  python main.py kline --source tencent # 使用腾讯数据源
  python main.py kline --test         # 测试K线分析器功能
  
  📊 股票涨跌趋势排行 (智能排序+趋势符号)
  python main.py trend --config       # 显示配置文件股票的趋势排行
  python main.py trend --gainers --top 10 --config # 显示涨幅榜前10名  
  python main.py trend --losers --top 10 --config  # 显示跌幅榜前10名
  python main.py trend --dual --top 5 --config     # 显示涨跌双榜对比
  python main.py trend --all --config             # 显示所有股票的完整趋势排行
  python main.py trend --gainers --top 20         # 全市场涨幅榜TOP20
  
  💡 多数据源智能切换特性:
  - 主数据源失败时自动切换到备用数据源
  - 新浪、腾讯数据源：稳定快速，推荐使用
  - yfinance数据源：作为备用，可能遇到速率限制但会自动切换
  - auto模式：单个股票级别智能切换，确保最高成功率
  - 智能切换确保100%数据获取成功率
        """
    )
    
    # 添加子命令
    subparsers = parser.add_subparsers(dest='module', help='功能模块')
    
    # A股监控模块
    a_parser = subparsers.add_parser('a', help='A股实时行情监控')
    a_parser.add_argument(
        '--interval', '-i', 
        type=int, 
        default=5,
        help='刷新间隔(秒) 默认:5'
    )
    a_parser.add_argument(
        '--source', '-s',
        choices=['sina', 'tencent', 'qq', 'yfinance', 'yahoo', 'yf', 'auto'],
        default='sina',
        help='数据源 默认:sina (可选: sina, tencent, yfinance, auto)'
    )
    a_parser.add_argument(
        '--config', '-c',
        default='config/stocks.yaml',
        help='配置文件路径 默认:config/stocks.yaml'
    )
    a_parser.add_argument(
        '--test', '-t',
        action='store_true',
        help='仅测试数据源连接，不启动监控'
    )
    a_parser.add_argument(
        '--once',
        action='store_true',
        help='仅获取一次数据，不持续监控'
    )
    
    # A股涨幅排名模块
    rank_parser = subparsers.add_parser('rank', help='A股涨幅排名')
    rank_parser.add_argument(
        '--top', '-n',
        type=int,
        default=50,
        help='显示前N名 默认:50'
    )
    rank_parser.add_argument(
        '--source', '-s',
        choices=['sina', 'tencent', 'qq', 'yfinance', 'yahoo', 'yf', 'auto'],
        default='sina',
        help='数据源 默认:sina (可选: sina, tencent, yfinance, auto)'
    )
    rank_parser.add_argument(
        '--test', '-t',
        action='store_true',
        help='仅测试数据源连接'
    )
    rank_parser.add_argument(
        '--losers', '-l',
        action='store_true',
        help='显示跌幅排名而非涨幅排名'
    )
    rank_parser.add_argument(
        '--limit', '-u',
        action='store_true',
        help='显示涨停股票榜（按涨停标准筛选）'
    )
    
    # AI智能选股模块
    ai_parser = subparsers.add_parser('ai', help='DeepSeek AI智能选股器')
    ai_parser.add_argument(
        '--count', '-c',
        type=int,
        default=10,
        help='推荐股票数量 默认:10'
    )
    ai_parser.add_argument(
        '--source', '-s',
        choices=['sina', 'tencent', 'qq', 'yfinance', 'yahoo', 'yf', 'auto'],
        default='tencent',
        help='数据源 默认:tencent (可选: sina, tencent, yfinance, auto)'
    )
    ai_parser.add_argument(
        '--test', '-t',
        action='store_true',
        help='仅测试AI选股器连接'
    )
    ai_parser.add_argument(
        '--themes-only',
        action='store_true',
        help='仅显示题材分析，不进行选股'
    )
    ai_parser.add_argument(
        '--monthly-patterns',
        action='store_true',
        help='显示月度炒作规律分析'
    )
    ai_parser.add_argument(
        '--no-ai',
        action='store_true',
        help='禁用DeepSeek AI分析'
    )
    ai_parser.add_argument(
        '--api-key',
        type=str,
        help='DeepSeek API密钥'
    )
    
    # 增强版AI选股模块
    enhanced_parser = subparsers.add_parser('enhanced', help='增强版AI选股器（全市场扫描+新闻分析）')
    enhanced_parser.add_argument(
        '--count',
        type=int,
        default=10,
        help='推荐股票数量 默认:10'
    )
    enhanced_parser.add_argument(
        '--source',
        choices=['sina', 'tencent', 'qq', 'yfinance', 'yahoo', 'yf', 'auto'],
        default='tencent',
        help='数据源 默认:tencent (可选: sina, tencent, yfinance, auto)'
    )
    enhanced_parser.add_argument(
        '--theme',
        type=str,
        help='特定题材深度分析（如：人工智能、新能源等）'
    )
    enhanced_parser.add_argument(
        '--no-news',
        action='store_true',
        help='禁用新闻分析'
    )
    enhanced_parser.add_argument(
        '--no-ai',
        action='store_true',
        help='禁用DeepSeek AI分析'
    )
    enhanced_parser.add_argument(
        '--min-price',
        type=float,
        default=5.0,
        help='最低股价筛选'
    )
    enhanced_parser.add_argument(
        '--max-price',
        type=float,
        default=300.0,
        help='最高股价筛选'
    )
    enhanced_parser.add_argument(
        '--min-volume',
        type=int,
        default=1000000,
        help='最小成交量筛选'
    )
    enhanced_parser.add_argument(
        '--exclude-st',
        action='store_true',
        default=True,
        help='排除ST股票'
    )
    enhanced_parser.add_argument(
        '--api-key',
        type=str,
        help='DeepSeek API密钥'
    )
    enhanced_parser.add_argument(
        '--test',
        action='store_true',
        help='测试增强版AI选股器连接'
    )
    
    # AI选股器v2.0专业版模块
    ai_v2_parser = subparsers.add_parser('ai-v2', help='AI选股器v2.0专业版（多因子+机器学习）')
    ai_v2_parser.add_argument(
        '--count',
        type=int,
        default=10,
        help='推荐股票数量 默认:10'
    )
    ai_v2_parser.add_argument(
        '--source',
        choices=['sina', 'tencent', 'qq', 'yfinance', 'yahoo', 'yf', 'auto'],
        default='tencent',
        help='数据源 默认:tencent (可选: sina, tencent, yfinance, auto)'
    )
    ai_v2_parser.add_argument(
        '--strategy',
        choices=['balanced', 'growth', 'value', 'momentum', 'quality', 'technical'],
        default='balanced',
        help='投资策略 默认:balanced'
    )
    ai_v2_parser.add_argument(
        '--risk',
        choices=['conservative', 'moderate', 'aggressive'],
        default='moderate',
        help='风险偏好 默认:moderate'
    )
    ai_v2_parser.add_argument(
        '--sector',
        type=str,
        help='指定板块分析（如：大盘蓝筹、科技成长、新能源、医药生物、消费）'
    )
    ai_v2_parser.add_argument(
        '--min-score',
        type=float,
        default=45.0,
        help='最低评分要求 默认:45.0'
    )
    ai_v2_parser.add_argument(
        '--no-ai',
        action='store_true',
        help='禁用DeepSeek R1 AI深度分析'
    )
    ai_v2_parser.add_argument(
        '--api-key',
        type=str,
        help='DeepSeek API密钥'
    )
    ai_v2_parser.add_argument(
        '--test',
        action='store_true',
        help='测试AI选股器v2.0连接'
    )
    
    # K线技术分析模块
    kline_parser = subparsers.add_parser(
        'kline', 
        help='K线技术分析和大资金识别',
        description='''
K线技术分析器 - 专业股票技术分析工具

支持功能：
• 基础分析：移动平均线、趋势识别、成交量分析
• 🆕 增强分析：6大技术指标(RSI/MACD/KDJ/布林带/ATR/威廉指标) + 风险管理
• 批量分析：支持多股票同时分析和筛选
• 个性化配置：账户价值和风险承受度自定义

使用示例：
  # 基础单股分析
  python main.py kline 601611 中国核建
  
  # 🆕 增强分析模式（推荐）
  python main.py kline 601611 中国核建 --enhanced
  
  # 个性化配置（账户20万，风险承受度3%）
  python main.py kline 601611 --account-value 200000 --risk-tolerance 0.03 --enhanced
  
  # 批量分析（基础模式）
  python main.py kline --batch
  
  # 🆕 增强批量分析
  python main.py kline --batch --enhanced --min-score 60 --signal-threshold 40
  
  # 自定义股票列表分析
  python main.py kline --stocks "601611,002162,601668" --enhanced
  
  # 不同投资者类型配置：
  # 保守型：高评分要求，低风险承受度
  python main.py kline --batch --enhanced --min-score 70 --account-value 100000 --risk-tolerance 0.01
  
  # 积极型：相对宽松条件，高风险承受度  
  python main.py kline --batch --enhanced --min-score 50 --account-value 300000 --risk-tolerance 0.03
        ''',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    kline_parser.add_argument(
        'stock_code',
        nargs='?',
        help='股票代码（如：601611）'
    )
    kline_parser.add_argument(
        'stock_name',
        nargs='?',
        help='股票名称（可选）'
    )
    kline_parser.add_argument(
        '--source', '-s',
        choices=['sina', 'tencent', 'qq', 'yfinance', 'yahoo', 'yf', 'auto'],
        default='tencent',
        help='数据源 默认:tencent (可选: sina, tencent, yfinance, auto)'
    )
    kline_parser.add_argument(
        '--batch', '-b',
        action='store_true',
        help='批量分析模式'
    )
    kline_parser.add_argument(
        '--stocks',
        type=str,
        help='股票代码列表，用逗号分隔（如：601611,002162,601668）'
    )
    kline_parser.add_argument(
        '--test', '-t',
        action='store_true',
        help='测试K线分析器功能'
    )
    kline_parser.add_argument(
        '--top-scored',
        type=int,
        help='显示评分最高的N只股票'
    )
    kline_parser.add_argument(
        '--account-value',
        type=float,
        default=100000,
        help='账户总价值 默认:100000'
    )
    kline_parser.add_argument(
        '--risk-tolerance',
        type=float,
        default=0.02,
        help='风险承受度 默认:0.02(2%%)'
    )
    kline_parser.add_argument(
        '--enhanced',
        action='store_true',
        help='启用增强分析模式（包含高级技术指标和风险管理）'
    )
    kline_parser.add_argument(
        '--min-score',
        type=float,
        default=50.0,
        help='最低综合评分筛选 默认:50.0'
    )
    kline_parser.add_argument(
        '--signal-threshold',
        type=float,
        default=30.0,
        help='大资金信号强度阈值 默认:30.0'
    )
    
    # 股票趋势排行模块
    trend_parser = subparsers.add_parser('trend', help='股票涨跌趋势排行')
    trend_parser.add_argument(
        '--source', '-s',
        choices=['sina', 'tencent', 'qq', 'yfinance', 'yahoo', 'yf', 'auto'],
        default='tencent',
        help='数据源选择 默认:tencent (可选: sina, tencent, yfinance, auto)'
    )
    trend_parser.add_argument(
        '--gainers', '-g',
        action='store_true',
        help='显示涨幅榜'
    )
    trend_parser.add_argument(
        '--losers', '-l',
        action='store_true',
        help='显示跌幅榜'
    )
    trend_parser.add_argument(
        '--dual', '-d',
        action='store_true',
        help='显示涨跌双榜'
    )
    trend_parser.add_argument(
        '--all', '-a',
        action='store_true',
        help='显示完整趋势排行'
    )
    trend_parser.add_argument(
        '--top', '-n',
        type=int,
        default=20,
        help='显示前N名 默认:20'
    )
    trend_parser.add_argument(
        '--config', '-c',
        action='store_true',
        help='只分析配置文件中的股票'
    )
    
    return parser


def handle_a_stock_module(args):
    """处理A股模块请求"""
    try:
        monitor = create_monitor(
            config_path=args.config,
            data_source=args.source
        )
        
        if args.test:
            # 仅测试连接
            print("🔍 测试A股数据源连接...")
            success = monitor.test_connection()
            if success:
                print("✅ 数据源连接测试成功")
                return 0
            else:
                print("❌ 数据源连接测试失败")
                return 1
        elif args.once:
            # 获取一次数据
            print("📊 获取A股行情数据...")
            quotes = monitor.get_quotes()
            if quotes:
                monitor.display_quotes(quotes)
                return 0
            else:
                print("❌ 获取行情数据失败")
                return 1
        else:
            # 启动持续监控
            print(f"🚀 启动A股行情监控 (间隔:{args.interval}秒, 数据源:{args.source})")
            monitor.start_monitoring(interval=args.interval)
            return 0
            
    except Exception as e:
        print(f"❌ A股模块执行失败: {e}")
        return 1


def handle_a_stock_ranking(args):
    """处理A股涨幅排名请求"""
    try:
        ranking = create_ranking_monitor(data_source=args.source)
        
        if args.test:
            # 仅测试连接
            print("🔍 测试排名数据源连接...")
            success = ranking.test_connection()
            if success:
                print("✅ 数据源连接测试成功")
                return 0
            else:
                print("❌ 数据源连接测试失败")
                return 1
        else:
            if args.limit:
                # 获取涨停榜
                print("🚀 正在获取A股涨停榜...")
                print("⏳ 请耐心等待，正在扫描5000+只A股数据...")
                
                limit_up_stocks = ranking.get_limit_up_stocks(exclude_st=True)
                
                if limit_up_stocks:
                    ranking.display_limit_up_ranking(limit_up_stocks)
                    return 0
                else:
                    print("❌ 当前没有涨停股票")
                    return 1
            elif args.losers:
                # 获取跌幅排名
                print(f"📉 正在获取A股全市场跌幅排名TOP{args.top}...")
                print("⏳ 请耐心等待，正在扫描5000+只A股数据...")
                
                top_losers = ranking.get_top_losers(args.top)
                
                if top_losers:
                    ranking.display_losers_ranking(top_losers, args.top)
                    return 0
                else:
                    print("❌ 未能获取到排名数据，请检查网络连接或稍后重试")
                    return 1
            else:
                # 获取涨幅排名
                print(f"📈 正在获取A股全市场涨幅排名TOP{args.top}...")
                print("⏳ 请耐心等待，正在扫描5000+只A股数据...")
                
                top_gainers = ranking.get_top_gainers(args.top)
                
                if top_gainers:
                    ranking.display_ranking(top_gainers, args.top)
                    return 0
                else:
                    print("❌ 未能获取到排名数据，请检查网络连接或稍后重试")
                    return 1
            
    except KeyboardInterrupt:
        print("\n\n👋 用户中断，程序退出")
        return 0
    except Exception as e:
        print(f"❌ 排名模块执行失败: {e}")
        return 1


def handle_ai_stock_selector(args):
    """处理DeepSeek AI智能选股请求"""
    try:
        # 设置API密钥环境变量
        if args.api_key:
            import os
            os.environ['DEEPSEEK_API_KEY'] = args.api_key
        
        # 创建AI选股器实例
        use_ai = not args.no_ai
        selector = create_ai_selector(data_source=args.source)
        selector.use_ai = use_ai
        
        if args.test:
            # 仅测试连接
            print("🔍 测试AI选股器数据源连接...")
            success = selector.test_connection()
            if success:
                print("✅ AI选股器数据源连接测试成功")
                if use_ai:
                    print("🤖 DeepSeek AI分析功能已启用")
                else:
                    print("⚠️ 使用传统算法分析（DeepSeek AI已禁用）")
                return 0
            else:
                print("❌ AI选股器数据源连接测试失败")
                return 1
        elif args.monthly_patterns:
            # 仅显示月度炒作规律
            print("📅 显示A股月度题材炒作规律分析...")
            selector.display_monthly_patterns_only()
            return 0
        elif args.themes_only:
            # 仅进行题材分析
            print("🎯 正在进行市场题材热度分析...")
            print("⏳ 请耐心等待，正在分析多个热门题材...")
            
            theme_analyses = selector.analyze_market_themes()
            
            if theme_analyses:
                # 显示题材分析结果
                print("\n" + "="*80)
                print("🎯 市场题材热度分析报告")
                print("="*80)
                
                print(f"\n📈 题材热度排行榜 (共分析{len(theme_analyses)}个题材):")
                for i, analysis in enumerate(theme_analyses, 1):
                    print(f"\n   {i}. {analysis.theme.value}")
                    print(f"      🔥 热度评分: {analysis.hot_score:.1f}/100")
                    print(f"      📊 趋势评分: {analysis.trend_score:.1f}/100") 
                    print(f"      ⚠️  风险评分: {analysis.risk_score:.1f}/100")
                    print(f"      💡 投资建议: {analysis.recommendation}")
                    
                    if analysis.top_stocks:
                        print(f"      🏆 优质标的: {', '.join([f'{s.name}({s.code})' for s in analysis.top_stocks[:3]])}...")
                
                print("\n" + "="*80)
                print("📢 免责声明：以上分析仅供参考，投资有风险，入市需谨慎！")
                print("="*80)
                return 0
            else:
                print("❌ 题材分析失败，请检查网络连接或稍后重试")
                return 1
        else:
            # 完整的智能选股分析
            ai_status = "DeepSeek AI分析" if use_ai else "传统算法分析"
            print(f"🤖 启动{ai_status} (目标推荐:{args.count}只, 数据源:{args.source})")
            print("⏳ 请耐心等待，正在进行全面的市场分析...")
            print("   📊 分析市场题材热度...")
            print("   🎯 筛选优质投资标的...")
            print("   ⚖️  评估风险等级...")
            print("   💡 生成投资策略...")
            if use_ai:
                print("   🤖 DeepSeek AI深度分析...")
            
            result = selector.intelligent_stock_selection(max_selections=args.count)
            
            if result and result.recommended_stocks:
                selector.display_selection_result(result)
                return 0
            else:
                print("❌ AI选股分析失败，请检查网络连接或稍后重试")
                return 1
                
    except KeyboardInterrupt:
        print("\n\n👋 用户中断，程序退出")
        return 0
    except Exception as e:
        print(f"❌ AI选股器执行失败: {e}")
        return 1


def handle_enhanced_ai_selector(args):
    """处理增强版AI选股器请求"""
    try:
        # 设置API密钥环境变量
        if args.api_key:
            import os
            os.environ['DEEPSEEK_API_KEY'] = args.api_key
        
        # 创建增强版选股器实例
        use_ai = not args.no_ai
        include_news = not args.no_news
        
        selector = create_enhanced_selector(args.source, use_ai)
        
        if args.test:
            success = selector.market_scanner.quotation is not None
            ai_status = "启用" if use_ai else "禁用"
            news_status = "启用" if include_news else "禁用"
            
            if success:
                print(f"✅ 增强版AI选股器连接测试成功！")
                print(f"📊 数据源：{args.source}")
                print(f"🤖 DeepSeek AI分析：{ai_status}")
                print(f"📰 新闻事件分析：{news_status}")
                print(f"🔍 扫描范围：全A股市场")
            else:
                print(f"❌ 增强版AI选股器连接测试失败！")
            return 0
        
        print("🚀 启动增强版AI选股器")
        print("=" * 50)
        print(f"📊 数据源: {args.source}")
        print(f"🔍 扫描范围: 全A股市场")
        print(f"🤖 AI分析: {'启用' if use_ai else '禁用'}")
        print(f"📰 新闻分析: {'启用' if include_news else '禁用'}")
        if args.theme:
            print(f"🎯 题材分析: {args.theme}")
        print(f"💰 价格区间: ¥{args.min_price} - ¥{args.max_price}")
        print(f"📈 最小成交量: {args.min_volume:,}")
        print("=" * 50)
        print("正在进行综合分析，请稍候...")
        
        # 执行综合选股分析
        result = selector.comprehensive_stock_selection(
            max_selections=args.count,
            analyze_theme=args.theme,
            include_news_analysis=include_news
        )
        
        # 显示结果
        selector.display_comprehensive_result(result)
        
    except KeyboardInterrupt:
        print("\n\n👋 用户中断，程序退出")
        return 0
    except Exception as e:
        print(f"❌ 增强版AI选股器执行失败: {e}")
        return 1


def handle_ai_selector_v2(args):
    """处理AI选股器v2.0请求 - 支持DeepSeek R1"""
    try:
        # 设置API密钥环境变量
        if args.api_key:
            import os
            os.environ['DEEPSEEK_API_KEY'] = args.api_key
        
        # 映射策略参数
        strategy_map = {
            'balanced': SelectionStrategy.BALANCED,
            'growth': SelectionStrategy.GROWTH,
            'value': SelectionStrategy.VALUE,
            'momentum': SelectionStrategy.MOMENTUM,
            'quality': SelectionStrategy.QUALITY,
            'technical': SelectionStrategy.TECHNICAL
        }
        
        # 映射风险偏好参数
        risk_map = {
            'conservative': RiskLevel.CONSERVATIVE,
            'moderate': RiskLevel.MODERATE,
            'aggressive': RiskLevel.AGGRESSIVE
        }
        
        strategy = strategy_map.get(args.strategy, SelectionStrategy.BALANCED)
        risk_tolerance = risk_map.get(args.risk, RiskLevel.MODERATE)
        use_ai = not args.no_ai
        
        # 创建AI选股器v2.0实例
        selector = create_ai_selector_v2(
            data_source=args.source,
            strategy=strategy,
            risk_tolerance=risk_tolerance,
            use_ai=use_ai
        )
        
        if args.test:
            print("🔍 正在测试AI选股器v2.0连接...")
            print("✅ AI选股器v2.0初始化成功")
            print("✅ 多因子模型加载完成")
            print("✅ 技术指标计算器就绪")
            print("✅ 数据源连接正常")
            if use_ai and selector.deepseek_ai:
                model_name = selector.deepseek_ai.model
                if model_name == "deepseek-reasoner":
                    print(f"🤖 DeepSeek R1推理模型已启用")
                else:
                    print(f"🤖 DeepSeek {model_name.upper()} AI分析已启用")
                if selector.deepseek_ai.reasoning_enabled:
                    print("🧠 R1推理模式已激活")
            elif use_ai:
                print("⚠️ DeepSeek AI初始化失败，将使用传统算法")
            else:
                print("⚠️ DeepSeek AI已禁用")
            return 0
        
        print(f"🚀 启动AI选股器v2.0专业版")
        print(f"📊 投资策略: {strategy.value}")
        print(f"⚖️  风险偏好: {risk_tolerance.value}")
        print(f"🎯 目标数量: {args.count}只")
        if args.sector:
            print(f"🏢 分析板块: {args.sector}")
        print(f"📏 最低评分: {args.min_score}分")
        
        # 显示AI状态
        if use_ai and selector.deepseek_ai:
            model_name = selector.deepseek_ai.model
            if model_name == "deepseek-reasoner":
                print(f"🤖 AI分析: DeepSeek R1推理模型")
            else:
                print(f"🤖 AI分析: DeepSeek {model_name.upper()}")
            if selector.deepseek_ai.reasoning_enabled:
                print("🧠 推理模式: R1深度推理已启用")
        elif use_ai:
            print("⚠️ AI分析: DeepSeek初始化失败，使用传统算法")
        else:
            print("📊 分析模式: 传统量化分析（AI已禁用）")
        
        # 准备板块筛选
        sector_filter = None
        if args.sector:
            # 支持中文板块名称映射
            sector_mapping = {
                "大盘蓝筹": ["大盘蓝筹"],
                "科技成长": ["科技成长"],
                "新能源": ["新能源"],
                "医药生物": ["医药生物"],
                "消费": ["消费"]
            }
            sector_filter = sector_mapping.get(args.sector, [args.sector])
        
        # 执行智能选股
        result = selector.intelligent_stock_selection(
            max_selections=args.count,
            min_score=args.min_score,
            sector_filter=sector_filter
        )
        
        # 显示结果
        selector.display_selection_result(result)
        
    except Exception as e:
        print(f"❌ AI选股器v2.0执行失败: {e}")
        import traceback
        traceback.print_exc()
        return 1


def handle_kline_analyzer(args):
    """处理K线技术分析请求"""
    try:
        print("🚀 启动K线技术分析和大资金识别系统")
        print("=" * 80)
        
        # 创建K线分析器
        analyzer = create_kline_analyzer(
            data_source=args.source,
            account_value=args.account_value,
            risk_tolerance=args.risk_tolerance
        )
        
        if args.test:
            # 测试模式
            print("🧪 测试K线分析器功能...")
            test_stocks = [("601611", "中国核建"), ("002162", "悦心健康")]
            results = analyzer.batch_analyze(test_stocks)
            
            if results:
                print("✅ K线分析器测试成功！")
                for result in results:
                    print(f"   {result.stock_code} {result.stock_name} - 综合评分: {result.overall_score:.1f}")
            else:
                print("❌ K线分析器测试失败")
            return 0
        
        if args.batch or args.stocks:
            # 批量分析模式
            stock_list = []
            
            if args.stocks:
                # 从命令行参数获取股票列表
                stock_codes = [code.strip() for code in args.stocks.split(',')]
                stock_list = [(code, f"股票{code}") for code in stock_codes]
            else:
                # 默认批量分析股票列表
                stock_list = [
                    ("601611", "中国核建"),
                    ("600019", "宝钢股份"),
                    ("002162", "悦心健康"),
                    ("601668", "中国建筑"),
                    ("603993", "洛阳钼业"),
                    ("002625", "光启技术"),
                    ("600435", "北方导航"),
                    ("000426", "兴业银锡")
                ]
            
            print(f"📊 开始批量分析 {len(stock_list)} 只股票...")
            results = analyzer.batch_analyze(stock_list)
            
            # 过滤结果
            filtered_results = []
            all_results = []
            for result in results:
                all_results.append(result)
                if (result.overall_score >= args.min_score and 
                    result.big_money_signal.signal_strength >= args.signal_threshold):
                    filtered_results.append(result)
            
            # 按综合评分排序
            filtered_results.sort(key=lambda x: x.overall_score, reverse=True)
            all_results.sort(key=lambda x: x.overall_score, reverse=True)
            
            # 限制显示数量
            if args.top_scored:
                filtered_results = filtered_results[:args.top_scored]
            
            print(f"\n📈 符合条件的股票 ({len(filtered_results)} 只):")
            print(f"筛选条件：综合评分 >= {args.min_score}, 大资金信号 >= {args.signal_threshold}")
            print(f"{'排名':<4} {'代码':<8} {'名称':<12} {'当前价':<8} {'综合评分':<8} {'大资金信号':<8} {'进入阶段':<8} {'风险等级'}")
            print("-" * 90)
            
            if filtered_results:
                for i, result in enumerate(filtered_results, 1):
                    print(f"{i:<4} {result.stock_code:<8} {result.stock_name:<12} "
                          f"¥{result.current_price:<7.2f} {result.overall_score:<8.1f} "
                          f"{result.big_money_signal.signal_strength:<8.1f} "
                          f"{result.big_money_signal.entry_stage:<8} {result.big_money_signal.risk_level}")
            else:
                print("暂无符合条件的股票")
                print(f"\n📊 所有股票评分情况:")
                print(f"{'代码':<8} {'名称':<12} {'当前价':<8} {'综合评分':<8} {'大资金信号':<8} {'状态'}")
                print("-" * 70)
                for result in all_results:
                    status = "✅符合" if (result.overall_score >= args.min_score and 
                                        result.big_money_signal.signal_strength >= args.signal_threshold) else "❌不符合"
                    print(f"{result.stock_code:<8} {result.stock_name:<12} "
                          f"¥{result.current_price:<7.2f} {result.overall_score:<8.1f} "
                          f"{result.big_money_signal.signal_strength:<8.1f} {status}")
                print(f"\n💡 建议：可以降低筛选条件，如 --min-score 40 --signal-threshold 20")
            
            # 显示详细分析（前3名）
            if filtered_results:
                print(f"\n🔍 详细分析报告（前3名）:")
                for i, result in enumerate(filtered_results[:3], 1):
                    print(f"\n{'='*20} 第{i}名详细分析 {'='*20}")
                    analyzer.display_analysis_result(result)
        
        elif args.stock_code:
            # 单只股票分析
            print(f"📊 开始分析股票: {args.stock_code}")
            if args.stock_name:
                print(f"    股票名称: {args.stock_name}")
            
            result = analyzer.analyze_stock(args.stock_code, args.stock_name)
            
            if result.overall_score > 0:
                if args.enhanced:
                    analyzer.display_enhanced_analysis_result(result)
                else:
                    analyzer.display_analysis_result(result)
                
                # 检查是否符合筛选条件
                if (result.overall_score >= args.min_score and 
                    result.big_money_signal.signal_strength >= args.signal_threshold):
                    print(f"\n✅ 该股票符合筛选条件！")
                    print(f"   综合评分: {result.overall_score:.1f} (>= {args.min_score})")
                    print(f"   大资金信号: {result.big_money_signal.signal_strength:.1f} (>= {args.signal_threshold})")
                else:
                    print(f"\n⚠️ 该股票不符合筛选条件")
                    print(f"   综合评分: {result.overall_score:.1f} (要求 >= {args.min_score})")
                    print(f"   大资金信号: {result.big_money_signal.signal_strength:.1f} (要求 >= {args.signal_threshold})")
            else:
                print("❌ 股票分析失败，请检查股票代码或网络连接")
        
        else:
            print("❌ 请提供股票代码或使用 --batch 参数进行批量分析")
            print("💡 使用示例:")
            print("   python main.py kline 601611")
            print("   python main.py kline --batch")
            print("   python main.py kline --stocks '601611,002162,601668'")
            return 1
        
        print(f"\n{'='*80}")
        print("📢 K线技术分析完成！")
        print("💡 提示：以上分析仅供参考，投资决策请结合多方面信息综合判断")
        print(f"{'='*80}")
        
        return 0
        
    except Exception as e:
        print(f"❌ K线技术分析失败: {e}")
        import traceback
        traceback.print_exc()
        return 1


def handle_trend_ranking(args):
    """处理股票趋势排行请求"""
    try:
        print("🚀 启动股票涨跌趋势排行分析")
        print("=" * 80)
        
        # 导入股票趋势排行器
        from modules.stock_trend_ranker import create_trend_ranker
        from modules.a_stock_monitor import create_monitor
        
        ranker = create_trend_ranker()
        
        if args.config:
            # 只分析配置文件中的股票
            print("📊 分析配置文件中的股票...")
            monitor = create_monitor(data_source=args.source)
            quotes = monitor.get_quotes()
        else:
            # 分析全市场股票（使用排名模块的全市场扫描）
            print("📊 正在扫描全市场股票...")
            print("⏳ 请耐心等待，正在获取市场行情数据...")
            
            from modules.a_stock_ranking import create_ranking_monitor
            ranking = create_ranking_monitor(data_source=args.source)
            quotes = ranking.get_all_stocks_data()
        
        if not quotes:
            print("❌ 未能获取到股票数据")
            return 1
        
        # 分析趋势
        trends = ranker.analyze_trends(quotes)
        
        if not trends:
            print("❌ 未能分析出有效的股票趋势数据")
            return 1
        
        print(f"✅ 成功分析了 {len(trends)} 只股票的趋势数据")
        
        # 根据参数显示不同的排行
        if args.gainers:
            # 显示涨幅榜
            gainers = ranker.get_top_gainers(trends, args.top)
            if gainers:
                sorted_gainers = ranker.sort_by_trend(gainers)
                ranker.display_trend_ranking(sorted_gainers, "涨幅排行榜", args.top)
            else:
                print("❌ 当前没有上涨的股票")
                
        elif args.losers:
            # 显示跌幅榜
            losers = ranker.get_top_losers(trends, args.top)
            if losers:
                from modules.stock_trend_ranker import SortOrder
                sorted_losers = ranker.sort_by_trend(losers, SortOrder.ASC)
                ranker.display_trend_ranking(sorted_losers, "跌幅排行榜", args.top)
            else:
                print("❌ 当前没有下跌的股票")
                
        elif args.dual:
            # 显示涨跌双榜
            ranker.display_gainers_and_losers(trends, args.top)
            
        elif args.all:
            # 显示完整趋势排行
            sorted_trends = ranker.sort_by_trend(trends)
            ranker.display_trend_ranking(sorted_trends, "完整趋势排行", len(trends))
            
        else:
            # 默认显示前N名（按涨跌幅排序）
            sorted_trends = ranker.sort_by_trend(trends)
            ranker.display_trend_ranking(sorted_trends, "股票涨跌趋势排行", args.top)
        
        print(f"\n{'='*80}")
        print("📢 趋势排行分析完成！")
        print("💡 提示：以上分析仅供参考，投资决策请结合多方面信息综合判断")
        print(f"{'='*80}")
        
        return 0
        
    except Exception as e:
        print(f"❌ 趋势排行分析失败: {e}")
        import traceback
        traceback.print_exc()
        return 1


def main():
    """主入口函数"""
    parser = setup_argument_parser()
    
    # 如果没有参数，显示帮助
    if len(sys.argv) == 1:
        parser.print_help()
        return 1
    
    args = parser.parse_args()
    
    # 根据模块分发请求
    if args.module == 'a':
        return handle_a_stock_module(args)
    elif args.module == 'rank':
        return handle_a_stock_ranking(args)
    elif args.module == 'ai':
        return handle_ai_stock_selector(args)
    elif args.module == 'enhanced':
        return handle_enhanced_ai_selector(args)
    elif args.module == 'ai-v2':
        return handle_ai_selector_v2(args)
    elif args.module == 'kline':
        return handle_kline_analyzer(args)
    elif args.module == 'trend':
        return handle_trend_ranking(args)
    else:
        print("❌ 未知的功能模块")
        parser.print_help()
        return 1


if __name__ == "__main__":
    exit(main()) 